package com.ms.controller;

import com.ms.entity.User;
import com.ms.service.inter.UserService;
import com.ms.utils.SimpleTokenUtils;
import jakarta.servlet.http.HttpServletRequest;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.util.*;

/**
 * 用户控制器 - 处理用户相关的HTTP请求
 * 包括用户注册、登录、信息修改等功能
 */
@RestController
@RequestMapping("/api/user")
@CrossOrigin(origins = "http://localhost:8080") // 允许跨域请求
public class UserController {

    @Autowired
    private UserService userService;

    /**
     * 查找指定年份前缀的最大numID
     * @param prefix 年份前缀，如"2023"
     * @return 最大的numID，如果没有找到则返回null
     */
    private String findMaxNumIdForYear(String prefix) {
        try {
            return userService.findMaxNumIdForYear(prefix);
        } catch (Exception e) {
            // 如果出现异常，返回null，使用默认值
            return null;
        }
    }

    /**
     * 用户注册接口
     * @param user 用户对象，包含注册信息
     * @return 注册结果
     */
    @PostMapping("/register")
    public ResponseEntity<Map<String, Object>> register(@RequestBody User user) {
        Map<String, Object> result = new HashMap<>();

        try {
            // 检查用户名是否已存在
            if (userService.findByUsername(user.getUsername()) != null) {
                result.put("success", false);
                result.put("message", "用户名已存在");
                return ResponseEntity.badRequest().body(result);
            }

            // 设置创建时间
            user.setCreateTime(new Date());
            
            // 生成numID（学号或工号）
            // 如果未提供numID，则生成递增格式的numID，如2023001, 2023002等
            if (user.getNumID() == null || user.getNumID().isEmpty()) {
                // 获取当前年份
                Calendar calendar = Calendar.getInstance();
                int currentYear = calendar.get(Calendar.YEAR);
                
                // 查询数据库中当前年份最大的numID
                String prefix = String.valueOf(currentYear);
                String maxNumId = findMaxNumIdForYear(prefix);
                
                if (maxNumId != null && !maxNumId.isEmpty()) {
                    // 提取数字部分并加1
                    // 例如从"2023001"中提取"001"然后转为整数1
                    String numberPart = maxNumId.substring(4); // 假设年份占4位
                    int maxNumber = Integer.parseInt(numberPart);
                    int nextNumber = maxNumber + 1;
                    user.setNumID(String.format("%d%03d", currentYear, nextNumber));
                } else {
                    // 如果没有找到当前年份的记录，则从001开始
                    // 先检查是否有任何记录，如果有则从最大编号+1开始
                    List<User> allUsers = userService.findAll();
                    int maxNumber = 0;
                    for (User u : allUsers) {
                        if (u.getNumID() != null && u.getNumID().startsWith(prefix)) {
                            try {
                                String numberPart = u.getNumID().substring(4);
                                int num = Integer.parseInt(numberPart);
                                if (num > maxNumber) {
                                    maxNumber = num;
                                }
                            } catch (NumberFormatException e) {
                                // 忽略格式不正确的numID
                            }
                        }
                    }
                    
                    if (maxNumber > 0) {
                        user.setNumID(String.format("%d%03d", currentYear, maxNumber + 1));
                    } else {
                        user.setNumID(String.format("%d%03d", currentYear, 1));
                    }
                }
            }

            // 保存用户信息
            userService.save(user);

            result.put("success", true);
            result.put("message", "注册成功");
            return ResponseEntity.ok(result);
        } catch (Exception e) {
            result.put("success", false);
            result.put("message", "注册失败: " + e.getMessage());
            return ResponseEntity.internalServerError().body(result);
        }
    }

    /**
     * 用户登录接口
     * @param account 用户账号（用户名、邮箱或手机号）
     * @param password 密码
     * @return 登录结果和令牌
     */
    @PostMapping("/login")
    public ResponseEntity<Map<String, Object>> login(@RequestParam String account, @RequestParam String password) {
        Map<String, Object> result = new HashMap<>();



        try {
            // 根据账号（用户名、邮箱或手机号）查找用户
            User user = userService.findByAccount(account);
            if (user == null) {
                result.put("success", false);
                result.put("message", "账号或密码错误");
                return ResponseEntity.badRequest().body(result);
            }

            // 直接比较密码，不进行加密验证
            if (!password.equals(user.getPassword())) {
                result.put("success", false);
                result.put("message", "账号或密码错误");
                return ResponseEntity.badRequest().body(result);
            }

            // 生成SimpleToken
            String token = SimpleTokenUtils.generateToken(user);

            result.put("success", true);
            result.put("message", "登录成功");
            result.put("token", token);
            result.put("user", user);
            return ResponseEntity.ok(result);
        } catch (Exception e) {
            result.put("success", false);
            result.put("message", "登录失败: " + e.getMessage());
            return ResponseEntity.internalServerError().body(result);
        }
    }

    /**
     * 获取用户信息接口
     * @param userId 用户ID
     * @param request HTTP请求
     * @return 用户信息
     */
    @GetMapping("/info")
    public ResponseEntity<Map<String, Object>> getUserInfo(@RequestParam Integer userId, HttpServletRequest request) {
        Map<String, Object> result = new HashMap<>();

        try {
            // 验证token
            String token = request.getHeader("token");
            if (token == null || token.isEmpty()) {
                result.put("success", false);
                result.put("message", "未登录");
                return ResponseEntity.badRequest().body(result);
            }

            Object userObj = SimpleTokenUtils.getUserByToken(token);
            if (!(userObj instanceof User)) {
                result.put("success", false);
                result.put("message", "无权限访问");
                return ResponseEntity.badRequest().body(result);
            }

            User user = userService.findById(userId);
            if (user == null) {
                result.put("success", false);
                result.put("message", "用户不存在");
                return ResponseEntity.badRequest().body(result);
            }

            // 不返回密码信息
            user.setPassword(null);

            result.put("success", true);
            result.put("user", user);
            return ResponseEntity.ok(result);
        } catch (Exception e) {
            result.put("success", false);
            result.put("message", "获取用户信息失败: " + e.getMessage());
            return ResponseEntity.internalServerError().body(result);
        }
    }

    /**
     * 更新用户信息接口
     * @param userId 用户ID
     * @param userData 更新的用户数据
     * @param request HTTP请求
     * @return 更新结果
     */
    @PutMapping("/update")
    public ResponseEntity<Map<String, Object>> updateUserInfo(@RequestParam Integer userId, @RequestBody Map<String, Object> userData, HttpServletRequest request) {
        Map<String, Object> result = new HashMap<>();

        try {
            // 验证token
            String token = request.getHeader("token");
            if (token == null || token.isEmpty()) {
                result.put("success", false);
                result.put("message", "未登录");
                return ResponseEntity.badRequest().body(result);
            }

            Object userObj = SimpleTokenUtils.getUserByToken(token);
            if (!(userObj instanceof User)) {
                result.put("success", false);
                result.put("message", "无权限访问");
                return ResponseEntity.badRequest().body(result);
            }

            User currentUser = (User) userObj;
            // 验证是否是本人操作
            if (!currentUser.getUserID().equals(userId)) {
                result.put("success", false);
                result.put("message", "无权限修改他人信息");
                return ResponseEntity.badRequest().body(result);
            }

            User existingUser = userService.findById(userId);
            if (existingUser == null) {
                result.put("success", false);
                result.put("message", "用户不存在");
                return ResponseEntity.badRequest().body(result);
            }

            // 检查是否是修改密码操作
            if (userData.containsKey("oldPassword") && userData.containsKey("newPassword")) {
                String oldPassword = (String) userData.get("oldPassword");
                String newPassword = (String) userData.get("newPassword");
                
                // 验证原密码是否正确
                if (!oldPassword.equals(existingUser.getPassword())) {
                    result.put("success", false);
                    result.put("message", "原密码错误");
                    return ResponseEntity.badRequest().body(result);
                }
                
                // 设置新密码
                existingUser.setPassword(newPassword);
            } else {
                // 更新允许修改的字段
                if (userData.containsKey("email")) {
                    existingUser.setEmail((String) userData.get("email"));
                }
                if (userData.containsKey("phone")) {
                    existingUser.setPhone((String) userData.get("phone"));
                }
                if (userData.containsKey("department")) {
                    existingUser.setDepartment((String) userData.get("department"));
                }
                if (userData.containsKey("grade")) {
                    existingUser.setGrade((String) userData.get("grade"));
                }
                if (userData.containsKey("major")) {
                    existingUser.setMajor((String) userData.get("major"));
                }
            }

            userService.update(existingUser);

            result.put("success", true);
            result.put("message", "用户信息更新成功");
            return ResponseEntity.ok(result);
        } catch (Exception e) {
            result.put("success", false);
            result.put("message", "更新用户信息失败: " + e.getMessage());
            return ResponseEntity.internalServerError().body(result);
        }
    }

    /**
     * 修改用户密码接口
     * @param userId 用户ID
     * @param oldPassword 原密码
     * @param newPassword 新密码
     * @param request HTTP请求
     * @return 修改结果
     */
    // 删除之前添加的changePassword方法，因为我们已经在updateUserInfo中实现了密码修改功能
}